home *** CD-ROM | disk | FTP | other *** search
/ Toolkit for Civilization 2 / Walnut Creek CDROM - Toolkit for Civilization II.iso / utils / unix / unzip512 / amiga / amiga.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-07-30  |  25.1 KB  |  777 lines
  1. /*------------------------------------------------------------------------
  2.  
  3.   amiga.c
  4.  
  5.   Amiga-specific routines for use with Info-ZIP's UnZip 5.1 and later.
  6.   See History.5xx for revision history.
  7.  
  8.   Contents:   mapattr()
  9.               mapname()
  10.               do_wild()
  11.               checkdir()
  12.               cmptime()
  13.               invlocal()
  14.               close_outfile()
  15.               _abort()         (Aztec C only)
  16.               version()
  17.  
  18.   ------------------------------------------------------------------------*/
  19.  
  20.  
  21. #include "unzip.h"
  22.  
  23. /* Globular varibundus */
  24.  
  25. static int created_dir;      /* used in mapname(), checkdir() */
  26. static int renamed_fullpath; /* ditto */
  27. #define PERMS   0777
  28. #define MKDIR(path,mode) mkdir(path)
  29.  
  30.  
  31. #ifndef S_ISCRIPT          /* not having one implies you have none */
  32. #  define S_IARCHIVE 0020  /* not modified since this bit was last set */
  33. #  define S_IREAD    0010  /* can be opened for reading */
  34. #  define S_IWRITE   0004  /* can be opened for writing */
  35. #  define S_IDELETE  0001  /* can be deleted */
  36. #endif /* S_ISCRIPT */
  37.  
  38. #ifndef S_IRWD
  39. #  define S_IRWD     0015  /* useful combo of Amiga privileges */
  40. #endif /* !S_IRWD */
  41.  
  42. #ifndef S_IHIDDEN
  43. #  define S_IHIDDEN  0200  /* hidden supported in future AmigaDOS (someday) */
  44. #endif /* !S_HIDDEN */
  45.  
  46.  
  47.  
  48. /**********************/
  49. /* Function mapattr() */
  50. /**********************/
  51.  
  52. int mapattr(void)      /* Amiga version */
  53. {
  54.     ulg  tmp = crec.external_file_attributes;
  55.  
  56.  
  57.     /* Amiga attributes = hsparwed = hidden, script, pure, archive,
  58.      * read, write, execute, delete */
  59.  
  60.     switch (pInfo->hostnum) {
  61.         case AMIGA_:
  62.             if ((tmp & 1) == (tmp>>18 & 1))
  63.                 tmp ^= 0x000F0000;      /* PKAZip compatibility kluge */
  64.             /* turn off archive bit for restored Amiga files */
  65.             pInfo->file_attr = (unsigned)((tmp>>16) & (~S_IARCHIVE));
  66.             break;
  67.  
  68.         case UNIX_:   /* preserve read, write, execute:  use logical-OR of */
  69.         case VMS_:    /* user, group, and other; if writable, set delete bit */
  70.             tmp >>= 16;
  71.             tmp = (( tmp>>6 | tmp>>3 | tmp) & 07) << 1;
  72.             pInfo->file_attr = (unsigned)(tmp&S_IWRITE? tmp|S_IDELETE : tmp);
  73.             break;
  74.  
  75.         /* all other platforms:  assume read-only bit in DOS half of attribute
  76.          * word is set correctly ==> will become READ or READ+WRITE+DELETE */
  77.         case FS_FAT_:
  78.         case FS_HPFS_:  /* can add S_IHIDDEN check to MSDOS/OS2/NT eventually */
  79.         case FS_NTFS_:
  80.         case MAC_:
  81.         case ATARI_:
  82.         case TOPS20_:
  83.         default:
  84.             pInfo->file_attr = (unsigned)(tmp&1? S_IREAD : S_IRWD); 
  85.             break;
  86.  
  87.     } /* end switch (host-OS-created-by) */
  88.  
  89.     pInfo->file_attr &= 0xff;   /* mask off all but lower eight bits */
  90.     return 0;
  91.  
  92. } /* end function mapattr() */
  93.  
  94.  
  95.  
  96.  
  97. /************************/
  98. /*  Function mapname()  */
  99. /************************/
  100.  
  101. int mapname(renamed)  /* return 0 if no error, 1 if caution (filename trunc), */
  102.     int renamed;      /* 2 if warning (skip file because dir doesn't exist), */
  103. {                     /* 3 if error (skip file), 10 if no memory (skip file) */
  104.     char pathcomp[FILNAMSIZ];   /* path-component buffer */
  105.     char *pp, *cp=NULL;         /* character pointers */
  106.     char *lastsemi = NULL;      /* pointer to last semi-colon in pathcomp */
  107.     int quote = FALSE;          /* flags */
  108.     int error = 0;
  109.     register unsigned workch;   /* hold the character being tested */
  110.  
  111.  
  112. /*---------------------------------------------------------------------------
  113.     Initialize various pointers and counters and stuff.
  114.   ---------------------------------------------------------------------------*/
  115.  
  116.     /* can create path as long as not just freshening, or if user told us */
  117.     create_dirs = (!fflag || renamed);
  118.  
  119.     created_dir = FALSE;        /* not yet */
  120.  
  121.     /* user gave full pathname:  don't prepend rootpath */
  122.     renamed_fullpath = (renamed && strchr(filename, ':'));
  123.  
  124.     if (checkdir((char *)NULL, INIT) == 10)
  125.         return 10;              /* initialize path buffer, unless no memory */
  126.  
  127.     *pathcomp = '\0';           /* initialize translation buffer */
  128.     pp = pathcomp;              /* point to translation buffer */
  129.     if (jflag)                  /* junking directories */
  130.         cp = (char *)strrchr(filename, '/');
  131.     if (cp == NULL)             /* no '/' or not junking dirs */
  132.         cp = filename;          /* point to internal zipfile-member pathname */
  133.     else
  134.         ++cp;                   /* point to start of last component of path */
  135.  
  136. /*---------------------------------------------------------------------------
  137.     Begin main loop through characters in filename.
  138.   ---------------------------------------------------------------------------*/
  139.  
  140.     while ((workch = (uch)*cp++) != 0) {
  141.  
  142.         if (quote) {                 /* if character quoted, */
  143.             *pp++ = (char)workch;    /*  include it literally */
  144.             quote = FALSE;
  145.         } else
  146.             switch (workch) {
  147.             case '/':             /* can assume -j flag not given */
  148.                 *pp = '\0';
  149.                 if ((error = checkdir(pathcomp, APPEND_DIR)) > 1)
  150.                     return error;
  151.                 pp = pathcomp;    /* reset conversion buffer for next piece */
  152.                 lastsemi = NULL;  /* leave directory semi-colons alone */
  153.                 break;
  154.  
  155.             case ';':             /* VMS version (or DEC-20 attrib?) */
  156.                 lastsemi = pp;         /* keep for now; remove VMS ";##" */
  157.                 *pp++ = (char)workch;  /*  later, if requested */
  158.                 break;
  159.  
  160.             case '\026':          /* control-V quote for special chars */
  161.                 quote = TRUE;     /* set flag for next character */
  162.                 break;
  163.  
  164.             default:
  165.                 /* allow European characters in filenames: */
  166.                 if (isprint(workch) || (128 <= workch && workch <= 255))
  167.                     *pp++ = (char)workch;
  168.             } /* end switch */
  169.  
  170.     } /* end while loop */
  171.  
  172.     *pp = '\0';                   /* done with pathcomp:  terminate it */
  173.  
  174.     /* if not saving them, remove with VMS version numbers (appended ";###") */
  175.     if (!V_flag && lastsemi) {
  176.         pp = lastsemi + 1;
  177.         while (isdigit((uch)(*pp)))
  178.             ++pp;
  179.         if (*pp == '\0')          /* only digits between ';' and end:  nuke */
  180.             *lastsemi = '\0';
  181.     }
  182.  
  183. /*---------------------------------------------------------------------------
  184.     Report if directory was created (and no file to create:  filename ended
  185.     in '/'), check name to be sure it exists, and combine path and name be-
  186.     fore exiting.
  187.   ---------------------------------------------------------------------------*/
  188.  
  189.     if (filename[strlen(filename) - 1] == '/') {
  190.         if (checkdir(filename, GETPATH) == 1) {
  191.             fprintf(stderr, "pathname too long:  truncat{ed/ing}\n");
  192.             return 1;  /* GRR:  NEEDS WORK! (do checking only when appending) */
  193.         }
  194.         if (created_dir && QCOND2) {
  195.             fprintf(stdout, "   creating: %s\n", filename);
  196.             return IZ_CREATED_DIR;   /* set dir time (note trailing '/') */
  197.         }
  198.         return 2;   /* dir existed already; don't look for data to extract */
  199.     }
  200.  
  201.     if (*pathcomp == '\0') {
  202.         fprintf(stderr, "mapname:  conversion of %s failed\n", filename);
  203.         return 3;
  204.     }
  205.  
  206.     if ((error = checkdir(pathcomp, APPEND_NAME)) == 1) {
  207.         /* GRR:  OK if truncated here:  warn and continue */
  208.         /* (warn in checkdir?) */
  209.     }
  210.     checkdir(filename, GETPATH);
  211.  
  212.     return error;
  213.  
  214. } /* end function mapname() */
  215.  
  216.  
  217. static int ispattern(char *p)
  218. {
  219.     register char c;
  220.     while (c = *p++)
  221.     if (c == '\\') {
  222.         if (!*++p)
  223.         return FALSE;
  224.         } else if (c == '?' || c == '*')
  225.             return TRUE;
  226.         else if (c == '[') {
  227.             for (;;) {
  228.                 if (!(c = *p++))
  229.                     return FALSE;
  230.                 else if (c == '\\') {
  231.                     if (!*++p)
  232.             return FALSE;
  233.                 } else if (c == ']')
  234.                     return TRUE;
  235.             }
  236.         }
  237.     return FALSE;
  238. }
  239.  
  240. /**********************/
  241. /* Function do_wild() */   /* for porting:  dir separator; match(ignore_case) */
  242. /**********************/
  243.  
  244. char *do_wild(wildspec)
  245.     char *wildspec;         /* only used first time on a given dir */
  246. {
  247.     static DIR *dir = NULL;
  248.     static char *dirname, *wildname, matchname[FILNAMSIZ];
  249.     static int firstcall=TRUE, have_dirname, dirnamelen;
  250.     struct dirent *file;
  251.     BPTR lok = 0;
  252.     /* Even when we're just returning wildspec, we *always* do so in
  253.      * matchname[]--calling routine is allowed to append four characters
  254.      * to the returned string, and wildspec may be a pointer to argv[].
  255.      */
  256.     if (firstcall) {        /* first call:  must initialize everything */
  257.         firstcall = FALSE;
  258.         /* avoid needless readdir() scans: */
  259.         if (!ispattern(wildspec) || (lok = Lock(wildspec, ACCESS_READ))) {
  260.             if (lok) UnLock(lok);
  261.             have_dirname = FALSE;
  262.             strcpy(matchname, wildspec);
  263.             return matchname;
  264.         }
  265.  
  266.         /* break the wildspec into a directory part and a wildcard filename */
  267.         if ((wildname = strrchr(wildspec, '/')) == NULL
  268.                         && (wildname = strrchr(wildspec, ':')) == NULL) {
  269.             dirname = "";               /* current dir */
  270.             dirnamelen = 1;
  271.             have_dirname = FALSE;
  272.             wildname = wildspec;
  273.         } else {
  274.             ++wildname;     /* point at character after '/' or ':' */
  275.             dirnamelen = wildname - wildspec;
  276.             if ((dirname = (char *)malloc(dirnamelen+1)) == NULL) {
  277.                 fprintf(stderr, "warning:  can't allocate wildcard buffers\n");
  278.                 strcpy(matchname, wildspec);
  279.                 return matchname;   /* but maybe filespec was not a wildcard */
  280.             }
  281.             strncpy(dirname, wildspec, dirnamelen);
  282.             dirname[dirnamelen] = 0;
  283.             have_dirname = TRUE;
  284.         }
  285.  
  286.         if ((dir = opendir(dirname)) != NULL) {
  287.             while ((file = readdir(dir)) != NULL) {
  288.                 if (match(file->d_name, wildname, 1)) {  /* case insensitive */
  289.                     if (have_dirname) {
  290.                         strcpy(matchname, dirname);
  291.                         strcpy(matchname+dirnamelen, file->d_name);
  292.                     } else
  293.                         strcpy(matchname, file->d_name);
  294.                     return matchname;
  295.                 }
  296.             }
  297.             /* if we get to here directory is exhausted, so close it */
  298.             closedir(dir);
  299.             dir = NULL;
  300.         }
  301.  
  302.         /* return the raw wildspec in case that works (e.g., directory not
  303.          * searchable, but filespec was not wild and file is readable) */
  304.         strcpy(matchname, wildspec);
  305.         return matchname;
  306.     }
  307.  
  308.     /* last time through, might have failed opendir but returned raw wildspec */
  309.     if (dir == NULL) {
  310.         firstcall = TRUE;  /* nothing left to try--reset for new wildspec */
  311.         if (have_dirname)
  312.             free(dirname);
  313.         return (char *)NULL;
  314.     }
  315.  
  316.     /* If we've gotten this far, we've read and matched at least one entry
  317.      * successfully (in a previous call), so dirname has been copied into
  318.      * matchname already.
  319.      */
  320.     while ((file = readdir(dir)) != NULL)
  321.         if (match(file->d_name, wildname, 0)) {   /* 0 == don't ignore case */
  322.             if (have_dirname) {
  323.                 /* strcpy(matchname, dirname); */
  324.                 strcpy(matchname+dirnamelen, file->d_name);
  325.             } else
  326.                 strcpy(matchname, file->d_name);
  327.             return matchname;
  328.         }
  329.  
  330.     closedir(dir);     /* have read at least one dir entry; nothing left */
  331.     dir = NULL;
  332.     firstcall = TRUE;  /* reset for new wildspec */
  333.     if (have_dirname)
  334.         free(dirname);
  335.     return (char *)NULL;
  336.  
  337. } /* end function do_wild() */
  338.  
  339.  
  340.  
  341. /***********************/
  342. /* Function checkdir() */
  343. /***********************/
  344.  
  345. int checkdir(pathcomp, flag)
  346.     char *pathcomp;
  347.     int flag;
  348. /*
  349.  * returns:  1 - (on APPEND_xxx) truncated path component
  350.  *           2 - path doesn't exist, not allowed to create
  351.  *           3 - path doesn't exist, tried to create and failed; or
  352.  *               path exists and is not a directory, but is supposed to be
  353.  *          10 - can't allocate memory for filename buffers
  354.  */
  355. {
  356.     static int rootlen = 0;   /* length of rootpath */
  357.     static char *rootpath;    /* user's "extract-to" directory */
  358.     static char *buildpath;   /* full path (so far) to extracted file */
  359.     static char *end;         /* pointer to end of buildpath ('\0') */
  360.  
  361. #   define FN_MASK   7
  362. #   define FUNCTION  (flag & FN_MASK)
  363.  
  364.  
  365.  
  366. /*---------------------------------------------------------------------------
  367.     APPEND_DIR:  append the path component to the path being built and check
  368.     for its existence.  If doesn't exist and we are creating directories, do
  369.     so for this one; else signal success or error as appropriate.
  370.   ---------------------------------------------------------------------------*/
  371.  
  372. /* GRR:  check path length after each segment:  warn about truncation */
  373.  
  374.     if (FUNCTION == APPEND_DIR) {
  375.         Trace((stderr, "appending dir segment [%s]\n", pathcomp));
  376.         while ((*end = *pathcomp++))
  377.             ++end;
  378.         if (stat(buildpath, &statbuf)) {   /* path doesn't exist */
  379.             if (!create_dirs) {   /* told not to create (freshening) */
  380.                 free(buildpath);
  381.                 return 2;         /* path doesn't exist:  nothing to do */
  382.             }
  383.             if (MKDIR(buildpath, 0777) == -1) {   /* create the directory */
  384.                 fprintf(stderr, 
  385.                 "checkdir:  can't create %s\n           unable to process %s.\n"
  386.                   , buildpath, filename);
  387.                 fflush(stderr);
  388.                 free(buildpath);
  389.                 return 3;      /* path didn't exist, tried to create, failed */
  390.             }
  391.             created_dir = TRUE;
  392.         } else if (!S_ISDIR(statbuf.st_mode)) {
  393.             fprintf(stderr, "checkdir:  %s exists but is not a directory\n\
  394.            unable to process %s.\n", buildpath, filename);
  395.             fflush(stderr);
  396.             free(buildpath);
  397.             return 3;          /* path existed but wasn't dir */
  398.         }
  399.         *end++ = '/';
  400.         *end = '\0';
  401.         Trace((stderr, "buildpath now = [%s]\n", buildpath));
  402.         return 0;
  403.  
  404.     } /* end if (FUNCTION == APPEND_DIR) */
  405.  
  406. /*---------------------------------------------------------------------------
  407.     GETPATH:  copy full path to the string pointed at by pathcomp, and free
  408.     buildpath.
  409.   ---------------------------------------------------------------------------*/
  410.  
  411.     if (FUNCTION == GETPATH) {
  412.         strcpy(pathcomp, buildpath);  /* DO ERROR CHECKING:  TOO LONG? */
  413.         Trace((stderr, "getting and freeing path [%s]\n", pathcomp));
  414.         free(buildpath);
  415.         buildpath = end = NULL;
  416.         return 0;
  417.     }
  418.  
  419. /*---------------------------------------------------------------------------
  420.     APPEND_NAME:  assume the path component is the filename; append it and
  421.     return without checking for existence.
  422.   ---------------------------------------------------------------------------*/
  423.  
  424.     if (FUNCTION == APPEND_NAME) {                /* DO ERROR CHECKING */
  425.         Trace((stderr, "appending filename [%s]\n", pathcomp));
  426.         while ((*end = *pathcomp++))
  427.             ++end;
  428.         Trace((stderr, "buildpath now = [%s]\n", buildpath));
  429.         return 0;  /* could check for existence here, prompt for new name... */
  430.     }
  431.  
  432. /*---------------------------------------------------------------------------
  433.     INIT:  allocate and initialize buffer space for the file currently being
  434.     extracted.  If file was renamed with an absolute path, don't prepend the
  435.     extract-to path.
  436.   ---------------------------------------------------------------------------*/
  437.  
  438.     if (FUNCTION == INIT) {
  439.         Trace((stderr, "initializing buildpath to "));
  440.         if ((buildpath = (char *)malloc(strlen(filename)+rootlen+1)) == NULL)
  441.             return 10;
  442.         if ((rootlen > 0) && !renamed_fullpath) {
  443.             strcpy(buildpath, rootpath);
  444.             end = buildpath + rootlen;
  445.         } else {
  446.             *buildpath = '\0';
  447.             end = buildpath;
  448.         }
  449.         Trace((stderr, "[%s]\n", buildpath));
  450.         return 0;
  451.     }
  452.  
  453. /*---------------------------------------------------------------------------
  454.     ROOT:  if appropriate, store the path in rootpath and create it if neces-
  455.     sary; else assume it's a zipfile member and return.  This path segment
  456.     gets used in extracting all members from every zipfile specified on the
  457.     command line.
  458.   ---------------------------------------------------------------------------*/
  459.  
  460. #if (!defined(SFX) || defined(SFX_EXDIR))
  461.     if (FUNCTION == ROOT) {
  462.         Trace((stderr, "initializing root path to [%s]\n", pathcomp));
  463.         if (pathcomp == NULL) {
  464.             rootlen = 0;
  465.             return 0;
  466.         }
  467.         if ((rootlen = strlen(pathcomp)) > 0) {
  468.             int had_trailing_pathsep=FALSE;
  469.  
  470.             if (pathcomp[rootlen-1] == '/') {
  471.                 pathcomp[--rootlen] = '\0';
  472.                 had_trailing_pathsep = TRUE;
  473.             }
  474.             if (rootlen > 0 && (stat(pathcomp, &statbuf) ||
  475.                 !S_ISDIR(statbuf.st_mode)))      /* path does not exist */
  476.             {
  477.                 if (!create_dirs                     /* || iswild(pathcomp) */
  478. #ifdef OLD_EXDIR
  479.                                  || !had_trailing_pathsep
  480. #endif
  481.                                                          ) {
  482.                     rootlen = 0;
  483.                     return 2;   /* treat as stored file */
  484.                 }
  485.                 /* create the directory (could add loop here to scan pathcomp
  486.                  * and create more than one level, but why really necessary?) */
  487.                 if (MKDIR(pathcomp, 0777) == -1) {
  488.                     fprintf(stderr,
  489.                       "checkdir:  can't create extraction directory: %s\n",
  490.                       pathcomp);
  491.                     fflush(stderr);
  492.                     rootlen = 0;   /* path didn't exist, tried to create, and */
  493.                     return 3;  /* failed:  file exists, or 2+ levels required */
  494.                 }
  495.             }
  496.             if ((rootpath = (char *)malloc(rootlen+2)) == NULL) {
  497.                 rootlen = 0;
  498.                 return 10;
  499.             }
  500.             strcpy(rootpath, pathcomp);
  501.             if (rootpath[rootlen - 1] != ':')
  502.                 rootpath[rootlen++] = '/';
  503.             rootpath[rootlen] = '\0';
  504.         }
  505.         Trace((stderr, "rootpath now = [%s]\n", rootpath));
  506.         return 0;
  507.     }
  508. #endif /* !SFX || SFX_EXDIR */
  509.  
  510. /*---------------------------------------------------------------------------
  511.     END:  free rootpath, immediately prior to program exit.
  512.   ---------------------------------------------------------------------------*/
  513.  
  514.     if (FUNCTION == END) {
  515.         Trace((stderr, "freeing rootpath\n"));
  516.         if (rootlen > 0)
  517.             free(rootpath);
  518.         return 0;
  519.     }
  520.  
  521.     return 99;  /* should never reach */
  522.  
  523. } /* end function checkdir() */
  524.  
  525.  
  526. /**********************/
  527. /* Function cmptime() */
  528. /**********************/
  529.  
  530. /* cmptime() clone pinched from from Zip1.9h,
  531.  * by Mark Adler, Jean-loup Gailly, et al., circa 1991.  
  532.  * Incorporated into UnZip 5.1d by John Bush
  533.  */
  534.  
  535. int cmptime(p, q)
  536. struct tm *p, *q;       /* times to compare */
  537. /* Return negative if time p is before time q, positive if after, and
  538.    zero if the same */
  539. {
  540.   int r;                /* temporary variable */
  541.  
  542.   if (p == NULL)
  543.     return -1;
  544.   else if ((r = p->tm_year - q->tm_year) != 0)
  545.     return r;
  546.   else if ((r = p->tm_mon - q->tm_mon) != 0)
  547.     return r;
  548.   else if ((r = p->tm_mday - q->tm_mday) != 0)
  549.     return r;
  550.   else if ((r = p->tm_hour - q->tm_hour) != 0)
  551.     return r;
  552.   else if ((r = p->tm_min - q->tm_min) != 0)
  553.     return r;
  554.   else
  555.     return p->tm_sec - q->tm_sec;
  556. }
  557.  
  558.  
  559. /***********************/
  560. /* Function invlocal() */
  561. /***********************/
  562.  
  563. /* mktime() clone pinched from from Zip1.9h,
  564.  * by Mark Adler and Jean-loup Gailly, et.al, circa 1991.  
  565.  * Incorporated into UnZip 5.1d by John Bush
  566.  */
  567. time_t invlocal(t)
  568. struct tm *t;           /* time to convert */
  569. /* Find inverse of localtime() using bisection.  This routine assumes that
  570.    time_t is an integer type, either signed or unsigned.  The expectation
  571.    is that sometime before the year 2038, time_t will be made a 64-bit
  572.    integer, and this routine will still work. */
  573. {
  574.   time_t i;             /* midpoint of current root range */
  575.   time_t l;             /* lower end of root range */
  576.   time_t u;             /* upper end of root range */
  577.  
  578.   /* Bracket the root [0,largest time_t].  Note: if time_t is a 32-bit signed
  579.      integer, then the upper bound is GMT 1/19/2038 03:14:07, after which all
  580.      the Unix systems in the world come to a grinding halt.  Either that, or
  581.      all those systems will suddenly find themselves transported to December
  582.      of 1901 ... */
  583.   l = 0;
  584.   u = 1;
  585.   while (u < (u << 1))
  586.     u = (u << 1) + 1;
  587.  
  588.   /* Find the root */
  589.   while (u - l > 1)
  590.   {
  591.     i = l + ((u - l) >> 1);
  592.     if (cmptime(localtime(&i), t) <= 0)
  593.       l = i;
  594.     else
  595.       u = i;
  596.   }
  597.   return l;
  598. }
  599.  
  600.  
  601.  
  602. /**************************************/
  603. /* Function close_outfile() */
  604. /**************************************/
  605. /* this part differs slightly with Zip */
  606. /*-------------------------------------*/
  607.  
  608. void close_outfile(void)
  609. {
  610.     struct tm t;                /* good ole time structure */
  611.     time_t u[2];                /* mean ole time stamp */
  612.     ulg dd,dt;                  /* DOS format time stamps */
  613.     LONG FileDate();
  614.     time_t invlocal();
  615.  
  616.     if (cflag)                  /* can't set time on stdout */
  617.         return;
  618.  
  619.   /* close the file *before* setting its time under AmigaDos */
  620.  
  621.     fclose(outfile);
  622.  
  623.   /* assign date and time to local variables */
  624.  
  625.     dd = lrec.last_mod_file_date;
  626.     dt = lrec.last_mod_file_time;
  627.  
  628.   /* Convert DOS time to time_t format in (time_t)u */
  629.  
  630.     t.tm_sec =   (int) (dt <<  1) & 0x3e;
  631.     t.tm_min =   (int) (dt >>  5) & 0x3f;
  632.     t.tm_hour =  (int) (dt >> 11) & 0x1f;
  633.  
  634.     t.tm_mday =  (int) (dd        & 0x1f);
  635.     t.tm_mon =  ((int) (dd >>  5) & 0xf ) - 1;
  636.     t.tm_year = ((int) (dd >>  9) & 0x7f) + 80;
  637.  
  638.   /* invlocal() is equivalent to mktime() */
  639.  
  640.     u[0] = u[1] = invlocal(&t); 
  641.  
  642. #ifdef DEBUG
  643.     fprintf (stderr,"\nclose_outfile(): u=%s\n",ctime(&u[0]));
  644. #endif
  645.  
  646.     if (!FileDate(filename, u))
  647.         fprintf(stderr, "warning:  can't set the time for %s\n", filename);
  648.  
  649.   /* set file perms after closing (not done at creation)--see mapattr() */
  650.  
  651.     chmod(filename, pInfo->file_attr);
  652.  
  653. } /* end function close_outfile() */
  654.  
  655.  
  656. /********************************************************************/
  657. /* Load filedate as a separate external file; it's used by Zip, too.*/
  658. /*                                                                  */
  659. #include "amiga/filedate.c"                                      /* */
  660. /*                                                                  */
  661. /********************************************************************/
  662.  
  663. /**************** for Aztec, do linewise with stat.c ****************/
  664.  
  665. #ifdef AZTEC_C
  666. #  include "amiga/stat.c"
  667. /* this is the exact same stat.c used for Aztec by Zip */
  668.  
  669. #  include <stdio.h>
  670. #  include "crypt.h"
  671.  
  672. void _abort(void)               /* called when ^C is pressed */
  673. {
  674.     echon();
  675.     close_leftover_open_dirs();
  676.     fflush(stdout);
  677.     fputs("\n^C\n", stderr);
  678.     exit(1);
  679. }
  680. #endif /* AZTEC_C */
  681.  
  682.  
  683. #ifndef SFX
  684.  
  685. /************************/
  686. /*  Function version()  */
  687. /************************/
  688.  
  689.  
  690. /* NOTE:  the following include depends upon the environment 
  691.  *        variable $Workbench to be set correctly.  (Set by
  692.  *        default, by kickstart during startup)
  693.  */
  694. int WBversion = (int)
  695. #include "ENV:Workbench"
  696. ;
  697.  
  698. void version()
  699. {
  700.    extern char Far  CompiledWith[];
  701.  
  702. /* Define buffers. */
  703.  
  704.    char buf1[16];  /* compiler name */
  705.    char buf2[16];  /* revstamp */
  706.    char buf3[16];  /* OS */
  707.    char buf4[16];  /* Date */
  708. /*   char buf5[16];  /* Time */
  709.  
  710. /* format "with" name strings */
  711.  
  712. #ifdef AMIGA
  713. # ifdef __SASC
  714.    strcpy(buf1,"SAS/C ");
  715. # else
  716. #  ifdef LATTICE
  717.     strcpy(buf1,"Lattice C ");
  718. #  else
  719. #   ifdef AZTEC_C
  720.      strcpy(buf1,"Manx Aztec C ");
  721. #   else
  722.      strcpy(buf1,"UNKNOWN ");
  723. #   endif
  724. #  endif
  725. # endif
  726. /* "under" */
  727.   sprintf(buf3,"AmigaDOS v%d",WBversion);
  728. #else
  729.   strcpy(buf1,"Unknown compiler ");
  730.   strcpy(buf3,"Unknown OS");
  731. #endif
  732.  
  733. /* Define revision, date, and time strings.  
  734.  * NOTE:  Do not calculate run time, be sure to use time compiled.
  735.  * Pass these strings via your makefile if undefined.
  736.  */
  737.  
  738. #if defined(__VERSION__) && defined(__REVISION__)
  739.   sprintf(buf2,"version %d.%d",__VERSION__,__REVISION__);
  740. #else
  741. # ifdef __VERSION__
  742.   sprintf(buf2,"version %d",__VERSION__);
  743. # else
  744.   sprintf(buf2,"unknown version");
  745. # endif
  746. #endif
  747.  
  748. #ifdef __DATE__
  749.   sprintf(buf4," on %s",__DATE__);
  750. #else
  751.   strcpy(buf4," unknown date");
  752. #endif
  753.  
  754. /******
  755. #ifdef __TIME__
  756.   sprintf(buf5," at %s",__TIME__);
  757. #else
  758.   strcpy(buf5," unknown time");
  759. #endif
  760. ******/
  761.  
  762. /* Print strings using "CompiledWith" mask defined in unzip.c (used by all).
  763.  *  ("Compiled with %s%s under %s%s%s%s.")
  764.  */
  765.  
  766.    printf(LoadFarString(CompiledWith),
  767.      buf1,
  768.      buf2, 
  769.      buf3,
  770.      buf4,
  771.      /* buf5, */ "",
  772.      "" );  /* buf6 not used */
  773.  
  774. } /* end function version() */
  775.  
  776. #endif /* !SFX */
  777.